package com.wk.contrller;

import com.wk.bean.*;
import com.wk.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@RestController
@RequestMapping("/auth") // 这里添加了 /auth 前缀
@CrossOrigin(origins = "http://localhost:8080")
public class UserController {
    @Autowired
    UserService userService;
    //注册接口
    @PostMapping("/register") // 定义一个POST请求映射，路径为"/register"，用于处理用户注册请求
    public ResponseEntity<Map<String, Object>> registerUser(@RequestBody WkUser user) { // 定义方法registerUser，接收一个用户对象作为参数，返回一个ResponseEntity对象，其中包含一个Map
        Map<String, Object> response = new HashMap<>(); // 创建一个HashMap对象，用于存储返回结果

        try { // 开始一个异常处理块
            WkUser existingUser = userService.queryUserByName(user.getUserName()); // 通过用户名查询是否已存在相同的用户

            if (existingUser != null) { // 如果已存在相同的用户
                response.put("status", 409); // 将Map中的status设为409（HTTP冲突状态码）
                response.put("message", "用户已存在"); // 将Map中的message设为"用户已存在"
                return ResponseEntity.status(HttpStatus.CONFLICT).body(response); // 返回一个ResponseEntity对象，状态码为HTTP冲突状态码，body为上述创建的Map
            }

            int result = userService.register(user); // 调用userService的register方法进行用户注册

            if (result == 0) { // 如果注册成功
                response.put("status", 201); // 将Map中的status设为201（HTTP创建状态码）
                response.put("message", "注册成功。"); // 将Map中的message设为"注册成功"
                response.put("user", user); // 将用户对象添加到Map中
                return ResponseEntity.status(HttpStatus.CREATED).body(response); // 返回一个ResponseEntity对象，状态码为HTTP创建状态码，body为上述创建的Map
            } else { // 如果注册失败
                response.put("status", 409); // 将Map中的status设为409（HTTP冲突状态码）
                // 或其他适当的状态码") // 或其他适当的状态码，如400，403等
                response.put("message", "注册失败"); // 将Map中的message设为"注册失败"
                return ResponseEntity.status(HttpStatus.CONFLICT).body(response); // 返回一个ResponseEntity对象，状态码为HTTP冲突状态码，body为上述创建的Map
            }
        } catch (Exception e) { // 如果在上述过程中发生异常
            response.put("status", 500); // 将Map中的status设为500（HTTP服务器错误状态码）
            // 或其他适当的状态码") // 或其他适当的状态码，如501，503等
            response.put("message", "注册失败"); // 将Map中的message设为"注册失败"
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response); // 返回一个ResponseEntity对象，状态码为HTTP服务器错误状态码，body为上述创建的Map
        }
    }
    // 登入接口
    @PostMapping("/login")
    public ResponseMsg<Map> login(@RequestBody WkUser user) {
        ResponseMsg<Map> res = new ResponseMsg<>();
        Map<String, Object> map = new HashMap<>();
        map.put("user_name", user.getUserName());
        try {
            WkUser dbUser = userService.queryUserByName(user.getUserName());
            if (dbUser != null && dbUser.getPassword().equals(user.getPassword())) {
                // 用户名存在且密码匹配，登录成功
                map.put("user", dbUser);
                map.put("state", "200");
                res.success("登录成功");
                res.setData(map);
            } else {
                // 用户名不存在或密码不匹配，登录失败
                map.put("state", "401");
                res.fail("登录失败");
                res.setData(map);
            }
        } catch (Exception e) {
            res.fail("登录失败");
        }
        return res;
    }


    @RequestMapping("/query")
    public List<Breakdown> queryBreakdown(@RequestBody Map<String, Object> params) {
        return userService.queryBreakdown(params);
    }
    @RequestMapping("/queryById")
    public String queryById( String id) {
        return id;
    }

    // 更新用户密码处理更新用户密码的POST请求
    @PostMapping("/updatePassword")
    //在这里，updateParams参数将会包含从HTTP请求体中映射而来的JSON数据，其中包含了更新密码所需的参数。
    public ResponseEntity<String> updatePassword(@RequestBody Map<String, Object> updateParams) {
        // 从请求参数中获取用户ID和新密码
        int userId = Integer.parseInt(updateParams.get("userId").toString());
        String newPassword = (String) updateParams.get("newPassword");
        // 通过用户ID检索用户
        WkUser user = userService.queryUserById(userId);

        if (user == null) {
            // 如果用户不存在，返回404状态码和消息
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("用户不存在");
        }

        // 更新密码
        user.setPassword(newPassword);
        int result = userService.updateUser(user);

        if (result > 0) {
            return ResponseEntity.ok("密码更新成功");
        } else {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("密码更新失败");
        }
    }

    //分页查询
    @PostMapping("/listUsersWithPagination")
    public ResponseEntity<Map<String, Object>> listUsersWithPagination(@RequestBody Map<String, Object> queryParams) {
        int page = Integer.parseInt(queryParams.get("page").toString());
        int pageSize = Integer.parseInt(queryParams.get("pageSize").toString());

        PageInfo pageInfo = new PageInfo();
        pageInfo.setOffset((page - 1) * pageSize);
        pageInfo.setPageSize(pageSize);

        List<WkUser> users = userService.listUsersWithPagination(pageInfo);

        Map<String, Object> response = new HashMap<>();
        if (users != null) {
            response.put("message", "成功获取用户列表。");
            response.put("users", users);
            return new ResponseEntity<>(response, HttpStatus.OK);
        } else {
            response.put("message", "未找到用户信息。");
            return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
        }
    }

    // 删除用户
    @PostMapping("/deleteUser")
    public ResponseEntity<String> deleteUser(@RequestBody Map<String, Object> deleteParams) {
        int userIdToDelete = Integer.parseInt(deleteParams.get("userId").toString()); // 获取要删除的用户ID
        int result = userService.deleteUser(userIdToDelete);

        if (result == 0) {
            // 删除成功，返回适当的成功消息
            return new ResponseEntity<>("删除成功", HttpStatus.OK);
        } else {
            // 删除失败或用户不存在，返回适当的错误信息
            return new ResponseEntity<>("删除失败.", HttpStatus.BAD_REQUEST);
        }
    }
    //添加用户
    @PostMapping("/addUser")
    public ResponseEntity<String> addUser(@RequestBody WkUser user) {
        int result = userService.insertUser(user);
        if (result == 1) {
            return new ResponseEntity<>("用户添加成功", HttpStatus.OK);
        } else {
            return new ResponseEntity<>("用户添加失败", HttpStatus.BAD_REQUEST);
        }
    }

    //查找
    @PostMapping("/queryUser")
    public ResponseEntity<?> queryUser(@RequestBody Map<String, Object> queryParams) {
        try {
            WkUser user = userService.queryUserByFields(queryParams);
            if (user != null) {
                return new ResponseEntity<>(user, HttpStatus.OK);
            } else {
                return new ResponseEntity<>("未找到用户信息。", HttpStatus.NOT_FOUND);
            }
        } catch (Exception e) {
            return new ResponseEntity<>("查询用户失败。", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    //菜单
    @GetMapping("/menu/queryMenuByRole")
    public ResponseMsg<List<Menu>> queryMenuByRole(@RequestParam("role_id") int role_id) {
        ResponseMsg<List<Menu>> res = new ResponseMsg<>();
        try {
            List<Menu> menus = userService.queryMenuByRole(role_id);
            res.success("查询成功");
            res.setData(menus);
        } catch (Exception e) {
            res.fail("查询失败");
        }
        return res;
    }

    // 更新用户信息，包括密码
    @PostMapping("/modifyUser")
    public ResponseEntity<String> updateUser(@RequestBody Map<String, Object> updateParams) {
        int userId = Integer.parseInt(updateParams.get("userId").toString());
        String newUserName = (String) updateParams.get("newUserName");
        String newPassword = (String) updateParams.get("newPassword");
        String newEmail = (String) updateParams.get("newEmail");
        int newRoleId = Integer.parseInt(updateParams.get("newRoleId").toString());

        // 通过用户ID检索用户
        WkUser user = userService.queryUserById(userId);

        if (user == null) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("用户不存在");
        }

        // 更新用户信息，包括密码
        user.setUserName(newUserName);
        user.setPassword(newPassword);
        user.setEmail(newEmail);
        user.setRoleId(String.valueOf(newRoleId));

        int result = userService.updateUser(user);

        if (result > 0) {
            return ResponseEntity.ok("用户信息更新成功");
        } else {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("用户信息更新失败");
        }
    }
    //上传文件
        @PostMapping("/upload")
        public String handleFileUpload(@RequestParam("file") MultipartFile file) {
            String fileName = file.getOriginalFilename();
            String filePath = "/path/to/upload/directory/" + fileName;

            try {
                File dest = new File(filePath);
                file.transferTo(dest);
                return "File uploaded successfully: " + filePath;
            } catch (IOException e) {
                e.printStackTrace();
                return "Error uploading file: " + e.getMessage();
            }
        }
    }






